home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / yase.arc / PRINTF.ASM < prev    next >
Encoding:
Assembly Source File  |  1986-12-13  |  9.6 KB  |  281 lines
  1. ******************************************************************
  2. * COPYRIGHT (C) 1986 by Donald Krantz and James Stanley
  3. * - Note: This is a real, live, actual, registered copyright,
  4. *   and should be treated as such. This source code is from
  5. *   the book "68000 Assembly Language", Krantz and Stanley,
  6. *   Addison-Wesley Publishing Company, Reading, MA, 1986.
  7. * 
  8. *   Permission granted by the authors for non-commercial use
  9. *   in programs released to the public domain, as long as this
  10. *   copyright notice remains attached and visible.
  11. *
  12. *****************************************************************
  13. * PRINTF - subset/superset of C printf standard I/O function
  14. * Control args:
  15. *
  16. *    push last parameter in control string first, then next-to
  17. *    last, etc.  Push address of control string last.
  18. *
  19. *     %d: print signed decimal word
  20. *     %u: print unsigned decimal word
  21. *     %D: print signed decimal longword
  22. *     %U: print unsigned decimal longword
  23. *     %x: print hexadecimal word
  24. *     %X: print hexadecimal longword
  25. *     %s: print null terminated string
  26. *     %c: print character
  27. *     %v: cursor (x,y) - push Y, then X, as words.
  28. *    %default: print next character as literal
  29. *****************************************************************
  30.     xdef    printf
  31.     xref    case,putc,cursor
  32. *****************************************************************
  33. * Local variable displacement definitions
  34. leftj    equ    -2        * left justify displacement
  35. field    equ    -4        * field width displacement
  36. signf    equ    -6        * sign flag
  37. *****************************************************************
  38. printf:
  39.     link    a6,#-6        * make 2 (word) local vars
  40.     movem.l    d0-d6/a0-a2,-(a7)
  41.     move.l    8(a6),a1    * get control string address
  42.     lea    12(a6),a2    * get pointer to parameters
  43. loop:
  44.     move.b    (a1)+,d0    * get control string character
  45.     beq    exit        * quit if it's a null.
  46.     ext.w    d0        * clear high byte
  47.     cmp.b    #'%',d0        * see if it's control flag
  48.     bne    no_ctl        * branch if not
  49.     clr.w    leftj(a6)    * clear left justify flag
  50.     clr.w    field(a6)    * clear field width
  51.     clr.w    signf(a6)    * clear sign flag
  52. lp0pf:
  53.     move.b    (a1)+,d0    * get control string character
  54.     ext.w    d0        * clear high byte 
  55.     cmp.b    #'-',d0        * is it minus?
  56.     bne    sk0pf        * no, keep going
  57.     move.w    #1,leftj(a6)     * set left justify flag
  58.     bra    lp0pf        * try for next char
  59. sk0pf:
  60.     cmp.b    #'0',d0        * is it smaller than a digit?
  61.     blt    sk1pf        * yes, continue processing
  62.     cmp.b    #'9',d0        * is it larger than a digit?
  63.     bgt    sk1pf        * yes, continue processing
  64.     move.w    field(a6),d1    * get current field size
  65.     mulu    #10,d1        * shift left one decimal digit
  66.     and.w    #$000F,d0    * make ASCII digit binary
  67.     add.w    d0,d1        * add current digit
  68.     move.w    d1,field(a6)    * store answer
  69.     bra    lp0pf        * get next format char        
  70. sk1pf:
  71.     move.l    #dispatch,a0    * get case table address for case
  72.     bra    case        * go do case select.
  73. no_ctl:
  74.     move.w    d0,-(a7)    * push character
  75.     bsr    putc        * print it
  76.     addq.l    #2,a7        * trash parameter
  77.     bra    loop        * do it again.
  78. exit:
  79.     movem.l    (a7)+,d0-d6/a0-a2
  80.     unlk    a6
  81.     rts
  82. *****************************************************************
  83. d_arg:
  84.     move.w    (a2)+,d0    * get value, move pointer
  85.     ext.l    d0        * convert to common format
  86.     bsr    sign        * print sign, if any, take abs()
  87.     bra    printdec    * go print value
  88. *****************************************************************
  89. u_arg:    
  90.     move.w    (a2)+,d0    * get value, move pointer
  91.     and.l    #$0000FFFF,d0    * zero out high word
  92.     bra    printdec    * go print value
  93. *****************************************************************
  94. D_arg:
  95.     move.l    (a2)+,d0    * get value, move pointer
  96.     bsr    sign        * print sign, if any, take abs()
  97.     bra    printdec    * go print value
  98. *****************************************************************
  99. U_arg:
  100.     move.l    (a2)+,d0    * get value, move pointer
  101.     bra    printdec    * print decimal value
  102. *****************************************************************
  103. * SIGN - print sign if needed and takes abs() of value
  104. sign:
  105.     tst.l    d0        * is it negative?
  106.     bpl    sk0_sg        * exit if not
  107.     move.w    #-1,signf(a6)    * flag sign needed
  108.     subq.w    #1,field(a6)    * take away one for sign
  109.     neg.l    d0        * change the sign
  110. sk0_sg:
  111.     rts
  112. *****************************************************************
  113. * printdec - common decimal output routine. Value in D0. 
  114. printdec:
  115.     clr.w    d1        * output digit count
  116. lp0_pd:
  117.     divu    #10,d0        * divide number by 10
  118.     bvs    o_flow        * number too large
  119.     swap    d0        * get remainder in d0.w
  120.     move.w    d0,-(a7)    * push digit
  121.     addq.w    #1,d1        * bump digit count
  122.     clr.w    d0        * get rid of remainder
  123.     swap    d0        * put quotient into d0.w
  124.     tst.w    d0        * zero means we're done
  125.     bne    lp0_pd        * jumps if not done.
  126.     move.w    d1,d6        * used for field adjust
  127.     bsr    prefix        * do prefix spaces
  128.     subq.w    #1,d1        * adjust loop index counter
  129. lp2_pd:
  130.     add.w    #$30,(a7)    * make digit TOS into ASCII
  131.     bsr    putc        * output digit
  132.     addq.l    #2,a7        * eat digit from TOS
  133.     dbra    d1,lp2_pd    * output all digits
  134.     bsr    postfix        * do postfix spaces
  135.     bra    loop        * exit to control parser
  136. o_flow:
  137.     move.l    #oflowstr,-(a7)    * push control string address
  138.     bsr    printf        * print it
  139.     addq.l    #4,a7        * adjust stack
  140.     bra    loop        * continue
  141. oflowstr:
  142.     dc.w    '*overflow*',0
  143. *****************************************************************
  144. * PREFIX - outputs prefix spaces and/or sign
  145. prefix:
  146.     tst.w    field(a6)    * check if field nonzero
  147.     ble    chksign        * if zero, just boogie on out
  148.     tst.w    leftj(a6)    * left justify selected?
  149.     bne    chksign        * jump if no
  150.     sub.w    d6,field(a6)    * digits allowed - digits actual
  151.     ble    chksign        * exit if no spaces needed
  152. lp0_pr:
  153.     move.w    d0,-(a7)    * save d0 across call to _put
  154.     move.w    #'  ',-(a7)    * space to output
  155.     bsr    putc        * output the space
  156.     addq.l    #2,a7        * adjust stack
  157.     move.w    (a7)+,d0    * retrieve d0
  158.     subq.w    #1,field(a6)    * decrement loop index
  159.     bne    lp0_pr        * do again if more spaces needed
  160. chksign:
  161.     tst.w    signf(a6)    * sign needed?
  162.     beq    chkexit        * jump if no
  163.     move.l    d0,d2        * save d0 across call to _put
  164.     move.w    #' -',-(a7)    * push sign
  165.     bsr    putc        * output it
  166.     addq.l    #2,a7        * adjust stack
  167.     move.l    d2,d0        * retrieve argument
  168. chkexit:
  169.     rts
  170. *****************************************************************
  171. * POSTFIX - prints postfix spaces in field
  172. postfix:
  173.     sub.w    d6,field(a6)    * digits allowed - digits actual
  174.     ble    sk1_po        * exit if no spaces needed
  175. lp0_po:
  176.     move.w    #'  ',-(a7)    * space to output
  177.     bsr    putc        * output the space
  178.     addq.l    #2,a7        * adjust stack
  179.     subq.w    #1,field(a6)    * decrement loop index
  180.     bne    lp0_po        * do again if more spaces needed
  181. sk1_po:
  182.     rts
  183. *****************************************************************
  184. x_arg:
  185.     move.w    #3,d1        * number of digits to print
  186.     move.w    #4,d6        * used for field adjust
  187.     move.w    (a2)+,d2    * transfer output value
  188.     swap    d2        * position output value
  189.     bra    printhex    * go print it
  190. *****************************************************************
  191. X_arg:
  192.     move.w    #7,d1        * number of digits to print
  193.     move.w    #8,d6        * used for field adjust
  194.     move.l    (a2)+,d2    * transfer output value
  195.     bra    printhex    * go print it
  196. *****************************************************************
  197. * PRINTHEX - outputs value held in D2 in hex. D1 is digit count
  198. printhex:
  199.     bsr    prefix        * output prefix spaces
  200. lp0ph:
  201.     move.l    #hexdigits,a0    * address of translate table
  202.     rol.l    #4,d2        * put MSD in low four bits
  203.     move.w    d2,d0        * we're only interested in LSD
  204.     and.w    #$000F,d0    * so we hack off all but LSD
  205.     move.b    0(a0,d0.w),d0    * get digit
  206.     move.w    d0,-(a7)    * push for output
  207.     bsr    putc        * output it
  208.     addq.l    #2,a7        * trash parameter
  209.     dbra    d1,lp0ph    * loop for next digit
  210.     bsr    postfix        * do postfix spaces
  211.     bra    loop        * return to control string parser
  212. hexdigits:
  213.     dc.w    '0123456789ABCDEF'
  214. *****************************************************************
  215. s_arg:
  216.     move.l    (a2),a0        * get string address from stack
  217.     clr.w    d6        * get strlen for field adjust
  218. slen:
  219.     tst.b    (a0)+        * look for terminal null
  220.     beq    sk0_sa        * jump if found
  221.     addq.w    #1,d6        * increment string length counter
  222.     bra    slen        * look at next byte
  223. sk0_sa:
  224.     move.l    (a2)+,a0    * get string address again
  225.     bsr    prefix        * print prefix spaces
  226. lp0_sa:
  227.     tst.b    (a0)        * end of string?
  228.     bne    sk1_sa        * no, keep going
  229.     bsr    postfix        * print postfix spaces
  230.     bra    loop        * continue parsing format string
  231. sk1_sa:
  232.     move.b    (a0)+,d0    * get char from string
  233.     move.w    d0,-(a7)    * push for output
  234.     bsr    putc        * output it
  235.     addq.l    #2,a7        * adjust stack
  236.     bra    lp0_sa        * continue
  237. *****************************************************************
  238. c_arg:
  239.     move.w    (a2)+,-(a7)    * get argument
  240.     bsr    putc        * send it out
  241.     addq.l    #2,a7        * adjust stack
  242.     bra    loop        * continue
  243. *****************************************************************
  244. v_arg:
  245.     move.l    (a2)+,-(a7)    * move both args at once
  246.     bsr    cursor        * perform function
  247.     addq.l    #4,a7        * adjust stack
  248.     bra    loop        * continue parse of control str
  249. *****************************************************************
  250. * DEFAULT: user has specified unknown control argument
  251. default:
  252.     move.w    d0,-(a7)    * we'll just print it.
  253.     bsr    putc        * so there it goes!
  254.     addq.l    #2,a7        * adjust stack
  255.     bra    loop        * that's all for here
  256. *****************************************************************
  257. * Case dispatch table for printf
  258. dispatch:
  259.     dc.w    9    * number of valid options
  260.      dc.b    0,'d'    * %d print signed decimal word 
  261.     dc.l    d_arg
  262.     dc.b    0,'u'    * %u print unsigned decimal word
  263.     dc.l    u_arg
  264.     dc.b    0,'D'    * %D print signed decimal longword
  265.     dc.l    D_arg
  266.     dc.b    0,'U'    * %U print unsigned decimal longword
  267.     dc.l    U_arg
  268.     dc.b    0,'x'    * %x print hex word
  269.     dc.l    x_arg
  270.     dc.b    0,'X'    * %X print hex longword
  271.     dc.l    X_arg
  272.     dc.b    0,'s'    * %s print null terminated string
  273.     dc.l    s_arg
  274.     dc.b    0,'c'    * %c print character
  275.     dc.l    c_arg
  276.     dc.b    0,'v'    * %v set cursor (X,Y)
  277.     dc.l    v_arg
  278.     dc.l    default    * all unknown cases handled here
  279.  
  280.     end
  281.